import java.util.Arrays;//这个Array工具导包是用来array数组的应用

//数组的课上练习
public class TestDemo {
    //1.数组转字符串
    //借助工具类快速打印
    public static int[] func3() {
        int[] array1 = {1, 2, 3, 4, 5, 6};
        return array1;
    }

    public static void main1(String[] args) {

        int[] ret = func3();
        //Arrays.toString(ret);用String来接受它的返回值
        //借助工具类将参数的数组转化为字符串输出
        String s = Arrays.toString(ret);
        System.out.println(s);
        //Java中提供了java.util.Arrays包,其中包含了一些操作数组的常用方法.
    }

    public static void main2(String[] args) {
        int[] ret = new int[]{1, 2, 3, 45, 6};
        String str = Arrays.toString(ret);//这部分要用String接受收，因为本质上是把数组转为字符串从而实现快速输出
        //System.out.println(str);
        System.out.println(Arrays.toString(ret));
    }

    //手动实现toString的方法
    public static String myToString(int[] array) {
        String s = "[";
        for (int i = 0; i < array.length; i++) {
            s += array[i];
            if (i != array.length - 1) {
                s += ",";
            }
        }
        //这部分使用字符串来拼接形成一个数组，但是由于数组的下标小于数组的长度，
        //所以当下标不等于长度的数小一个的数的时候，再打逗号，等于时，就不会打了
        s += "]";
        return s;
    }

    public static void main3(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        System.out.println(myToString(array));

    }

    //2.数组的拷贝

    /**
     * 真正的拷贝是深拷贝
     * 真正的拷贝是把数组的各项的值均复制，但是会创建一个新的空间，
     *  此时的地址也是不同的，但是仅有对象的值是相同的并且对象的位置也是不同你
     * 拷贝应该是指向的是不同的对象（在堆上），因为它们都是指向不同的对象，
     * 但是在栈上我们可以用发现他们会发现了不同的区域
     */
    //(1)第一种拷贝：
    public static void main4(String[] args) {
        int[] array = new int[]{1, 2, 3, 4, 5};
        //int[] 在Java中我们可以在[]中可以写变量，不局限于常量
        int a = 10;
        //int[] copy = new int[a];这个部分中的a就是变量
        int[] copy = new int[array.length];//同样这部分中也是如此。
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        System.out.println(Arrays.toString(copy));
    }

    public static void main5(String[] args) {
        int[] array =new int[]{1,2,3,4,5};
        int[] array1 =  array;
        System.out.println(Arrays.toString(array1));
        /**
         * 实际上这种情况不是一种拷贝，因为这种是用array1在Java虚拟机栈上来创建一个变量，同时array在虚拟机栈上也创建了一个变量，
         * 首先array指向了它在堆上的对象，然后通过赋值将array的地址传递给array1，这时候就会都指向了同一个对象
         */
    }
    public static void main6(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        int[] copy = Arrays.copyOf(array,array.length);//（拷贝的东西，拷贝的大小）
        System.out.println(Arrays.toString(copy));
        int[] copy2 = Arrays.copyOf(array,array.length+3);
        //此时就相当于扩容了
        System.out.println(Arrays.toString(copy2));
        int [] copy3 = Arrays.copyOfRange(array,0,3);//Arrays.copyOfRange() 拷贝一定的范围
        //拷贝一定的范围从下标开始，但是一定要记住的是左闭右开,[0，3)
        System.out.println(Arrays.toString(copy3));
    }

    public static void main7(String[] args) {
        //native 本地方法
        //本地方法的使用C/C++写的方法，就是快
        int[] array = new int[]{1,2,3,4,5};
        int[] copy = new int[array.length];
        //System.arraycopy(原数组，原数组的开始拷贝的位置，目的数组，目的数组开始的位置，拷贝的长度);
        System.arraycopy(array,0,copy,0,array.length);
        //System.arraycopy(array,0,copy,0,array.length+2);
        //ArrayIndexOutOfBoundsException（就是数组越界了）
        System.out.println(Arrays.toString(copy));

    }

    //手动实现拷贝
    public static int[] copyOf(int[] array){
        int[] copy = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;

    }
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};

        System.out.println(Arrays.toString(copyOf(array)));
    }
}
